package cn.appsys.controller.deve;

import java.io.File;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.commons.io.FilenameUtils;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import cn.appsys.constants.Constants;
import cn.appsys.pojo.AppCategory;
import cn.appsys.pojo.AppInfo;
import cn.appsys.pojo.AppVersion;
import cn.appsys.pojo.DataDictionary;
import cn.appsys.pojo.DevUser;
import cn.appsys.pojo.Page;
import cn.appsys.service.deve.appcategory.DevAppCategoryService;
import cn.appsys.service.deve.appinfo.DevAppInfoService;
import cn.appsys.service.deve.appversion.DevAppVersionService;
import cn.appsys.service.deve.dictionary.DevDataDictionaryService;

import com.mysql.jdbc.StringUtils;

@Controller
@RequestMapping("/devAppInfo")
public class DevAppInfoController {

	@Resource
	private DevAppInfoService devAppInfoService;
	@Resource
	private DevDataDictionaryService devDataDictionaryService;
	@Resource
	private DevAppCategoryService devAppCategoryService;
	@Resource
	private DevAppVersionService devAppVersionService;

	/**
	 * 分页并按照条件来查询app列表信息
	 * 
	 * @param model
	 *            模型对象
	 * @param querySoftwareName
	 *            软件名
	 * @param queryStatus
	 *            APP状态
	 * @param queryFlatformId
	 *            所属平台id
	 * @param queryCategoryLevel1
	 *            一级分类
	 * @param queryCategoryLevel2
	 *            一级分类
	 * @param queryCategoryLevel3
	 *            一级分类
	 * @param currPageNo
	 *            当前页码
	 * @return
	 */
	@RequestMapping("/list")
	public String list(
			Model model,
			@RequestParam(value = "querySoftwareName", required = false) String querySoftwareName,
			@RequestParam(value = "queryStatus", required = false) Integer queryStatus,
			@RequestParam(value = "queryFlatformId", required = false) Integer queryFlatformId,
			@RequestParam(value = "queryCategoryLevel1", required = false) Integer queryCategoryLevel1,
			@RequestParam(value = "queryCategoryLevel2", required = false) Integer queryCategoryLevel2,
			@RequestParam(value = "queryCategoryLevel3", required = false) Integer queryCategoryLevel3,
			@RequestParam(value = "pageIndex", required = false, defaultValue = "1") Integer pageIndex) {

		// 1.查询总记录数
		int totalCount = devAppInfoService.queryTotalCount(querySoftwareName,
				queryStatus, queryFlatformId, queryCategoryLevel1,
				queryCategoryLevel2, queryCategoryLevel3);
		// 2.创建分页实体类
		Page pages = new Page();
		pages.setCurrPageNo(pageIndex);// 传入当前页
		pages.setPageSize(5);// 传入页大小
		pages.setTotalCount(totalCount);// 传入总记录数
		int from = (pageIndex - 1) * pages.getPageSize();// 获取其实位置偏移量
		// 3.分页查询appinfo的信息
		List<AppInfo> appInfoList = devAppInfoService.queryAppInfoPage(
				querySoftwareName, queryStatus, queryFlatformId,
				queryCategoryLevel1, queryCategoryLevel2, queryCategoryLevel3,
				from, pages.getPageSize());
		// 4.查询app状态列表
		List<DataDictionary> statusList = devDataDictionaryService
				.queryByTypeCode("APP_STATUS");
		// 5.查询所属平台列表
		List<DataDictionary> flatFormList = devDataDictionaryService
				.queryByTypeCode("APP_FLATFORM");
		// 6.查询一级分类列表
		List<AppCategory> categoryLevel1List = devAppCategoryService
				.queryByParentId(null);
		List<AppCategory> categoryLevel2List = null;// 没有点选一级分类的时候 二级分类列表为空
		List<AppCategory> categoryLevel3List = null;// 没有点选二级分类的时候 三级分类列表为空
		// 7.查询二级分类列表（一级分类是否传值）
		if (queryCategoryLevel1 != null && queryCategoryLevel1 != 0) {
			categoryLevel2List = devAppCategoryService
					.queryByParentId(queryCategoryLevel1);
		}

		// 8.查询三级分类列表（二级分类是否传值）
		if (queryCategoryLevel2 != null && queryCategoryLevel2 != 0) {
			categoryLevel3List = devAppCategoryService
					.queryByParentId(queryCategoryLevel2);
		}

		model.addAttribute("statusList", statusList);
		model.addAttribute("flatFormList", flatFormList);
		model.addAttribute("categoryLevel1List", categoryLevel1List);
		model.addAttribute("categoryLevel2List", categoryLevel2List);
		model.addAttribute("categoryLevel3List", categoryLevel3List);
		model.addAttribute("appInfoList", appInfoList);
		model.addAttribute("pages", pages);
		// 回显
		model.addAttribute("querySoftwareName", querySoftwareName);
		model.addAttribute("queryCategoryLevel1", queryCategoryLevel1);
		model.addAttribute("queryCategoryLevel2", queryCategoryLevel2);
		model.addAttribute("queryCategoryLevel3", queryCategoryLevel3);
		model.addAttribute("queryStatus", queryStatus);
		model.addAttribute("queryFlatformId", queryFlatformId);

		return "developer/appinfolist";
	}

	/**
	 * 跳转到app新增页面
	 * 
	 * @return
	 */
	@RequestMapping("/toAppInfoAdd")
	public String toAppInfoAdd() {
		return "developer/appinfoadd";
	}

	/**
	 * 异步验证APKName是否存在
	 * 
	 * @param APKName
	 * @return
	 */
	@RequestMapping(value = "/ajaxApkNameIsExist", method = RequestMethod.GET)
	@ResponseBody
	public Object ajaxApkNameIsExist(@RequestParam("APKName") String APKName) {
		Map<String, String> map = new HashMap<String, String>();
		if (StringUtils.isNullOrEmpty(APKName)) {// 非空验证
			map.put("APKName", "empty");
		} else {// 不为空就根据apkName查询
			AppInfo app = devAppInfoService.queryAppInfoByAPKName(APKName);
			if (app != null) {// 如果有数据，就代表apkname已经存在
				map.put("APKName", "exist");
			} else {// 没有数据就代表apkname可用
				map.put("APKName", "noexist");
			}
		}
		return map;
	}

	/**
	 * 保存新增app基础信息
	 * 
	 * @param appInfo
	 * @param session
	 * @param request
	 * @param attach
	 * @return
	 */
	@RequestMapping(value = "/saveAppInfo")
	public String saveAppInfo(AppInfo appInfo, HttpSession session,
			HttpServletRequest request,
			@RequestParam("a_logoPicPath") MultipartFile attach) {
		// 判断是否执行新增操作
		boolean isOk = true;
		// 用于保存图片相对路径格式如：/AppInfoSystem/statics/uploadfiles/com.lbe.security.jpg
		String logoPicPath = null;
		// 用于保存图片的绝对路径
		String logoLocPath = null;

		// path的值格式为：G:\\tool\\01-zip\\apache-tomcat-7.0.62\\webapps\\AppInfoSystem\\statics\\uploadfiles
		String path = request.getSession().getServletContext()
				.getRealPath("statics" + File.separator + "uploadfiles");// 获取文件上传所需要的路径。
		if (!attach.isEmpty()) { // 不为空的情况，我们进行文件上传 statics\\uploadfiles
			String oldFileName = attach.getOriginalFilename(); // 得到上传图片的原文件名

			String suffix = FilenameUtils.getExtension(oldFileName);// 得到原文件的后缀
			if (attach.getSize() > 5000000) { // 如果上传文件的大小超过500kb
				request.setAttribute("fileUploadError",
						"* 上传文件的大小超过500kb，上传失败！");
				isOk = false;
			} else if (suffix.equalsIgnoreCase("jpg")
					|| suffix.equalsIgnoreCase("png")
					|| suffix.equalsIgnoreCase("jpeg")
					|| suffix.equalsIgnoreCase("pneg")) {
				// 判断用户上传的文件格式是否是jpg、png、jpeg、pneg格式
				String fileName = appInfo.getAPKName() + ".jpg";// 获取上传之后的文件名字，因为
																// APKName是唯一
				File file = new File(path, fileName); // 根据文件对象
				if (!file.exists()) { // 如果文件对象不存在，那么就创建这个目录
					file.mkdirs(); // 创建这个目录
				}
				try {
					attach.transferTo(file);// 将attach上传到指定的目录中去
				} catch (IllegalStateException | IOException e) {
					request.setAttribute("fileUploadError", "* 文件上传失败");
					e.printStackTrace();
				}
				logoPicPath = request.getContextPath()
						+ "/statics/uploadfiles/" + fileName; // 用于保存图片相对路径格式如：/AppInfoSystem/statics/uploadfiles/com.lbe.security.jpg
				logoLocPath = path + File.separator + fileName; // 保存的是图片的绝对路径
			} else {
				session.setAttribute("fileUploadError",
						"* 上传文件格式不是jpg、png、jpeg、pneg");
				isOk = false;
			}
		}
		if (isOk) {
			// 在进行新增操作时，createdBy及creationDate赋值
			appInfo.setCreatedBy(((DevUser) session
					.getAttribute(Constants.DEV_USER_SESSION)).getId()); // 创建者的用户id
			appInfo.setCreationDate(new Date()); // 新增时间
			appInfo.setLogoLocPath(logoLocPath);
			appInfo.setLogoPicPath(logoPicPath);
			int result = devAppInfoService.addAppInfo(appInfo);
			if (result > 0) {
				return "redirect:/devAppInfo/list"; // 新增成功跳转到app列表信息页面
			} else {
				return "developer/appinfoadd"; // 新增失败又跳转回新增页面
			}
		} else {
			return "developer/appinfoadd"; // 新增失败又跳转回新增页面
		}
	}

	/**
	 * 通过id查询appinfo并传送跳转到修改页面
	 * 
	 * @param appInfo
	 * @param model
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "/appinfomodify/{id}")
	public String appInfomodify(Model model, @PathVariable("id") Integer id) {
		// 通过id查询appinfo
		AppInfo appInfo = devAppInfoService.queryAppInfoById(id, null);
		// 保存appinfo的信息
		model.addAttribute("appInfo", appInfo);
		// 跳转到修改app基础信息页面
		return "developer/appinfomodify";
	}

	/**
	 * 根据id删除图片
	 * 
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "/ajaxDelfile/{id}", method = RequestMethod.GET)
	@ResponseBody
	public Object ajaxDelfile(@PathVariable("id") Integer id) {
		Map<String, String> map = new HashMap<String, String>();
		int result = devAppInfoService.upFileById(id);
		if (result > 0) {
			map.put("result", "success");
		} else {
			map.put("result", "failed");
		}
		// AppInfo appInfo = devAppInfoService.queryAppInfoById(id);
		// 保存删除图片后的appinfo的信息
		// model.addAttribute("appInfo", appInfo);
		return map;
	}

	/**
	 * 修改app基础信息(需要文件上传)
	 * 
	 * @param appInfo
	 * @param session
	 * @param request
	 * @param attach
	 * @return
	 */
	@RequestMapping("/modifysave")
	public String modifySave(AppInfo appInfo, HttpSession session,
			HttpServletRequest request,
			@RequestParam("attach") MultipartFile attach) {
		// 判断是否执行新增操作
		boolean isOk = true;

		String logoPicPath = ""; // 用于保存图片相对路径格式如：/AppInfoSystem/statics/uploadfiles/com.lbe.security.jpg
		String logoLocPath = ""; // 用于保存图片的绝对路径

		if (!attach.isEmpty()) { // 不为空的情况，我们进行文件上传 statics\\uploadfiles

			// path的值格式为：G:\\tool\\01-zip\\apache-tomcat-7.0.62\\webapps\\AppInfoSystem\\statics\\uploadfiles
			String path = request.getSession().getServletContext()
					.getRealPath("statics" + File.separator + "uploadfiles");// 获取文件上传所需要的路径。
			// 得到上传图片的原文件名
			String oldFileName = attach.getOriginalFilename();
			// 得到原文件的后缀
			String suffix = FilenameUtils.getExtension(oldFileName);
			if (attach.getSize() > 5000000) { // 如果上传文件的大小超过500kb
				request.setAttribute("fileUploadError",
						"* 上传文件的大小超过500kb，上传失败！");
				isOk = false;
			} else if (suffix.equalsIgnoreCase("jpg")
					|| suffix.equalsIgnoreCase("png")
					|| suffix.equalsIgnoreCase("jpeg")
					|| suffix.equalsIgnoreCase("pneg")) {
				// 判断用户上传的文件格式是否是jpg、png、jpeg、pneg格式
				String fileName = appInfo.getAPKName() + ".jpg";// 获取上传之后的文件名字，因为
																// APKName是唯一
				File file = new File(path, fileName); // 根据文件对象
				if (!file.exists()) { // 如果文件对象不存在，那么就创建这个目录
					file.mkdirs(); // 创建这个目录
				}
				try {
					attach.transferTo(file);// 将attach上传到指定的目录中去
				} catch (IllegalStateException | IOException e) {
					request.setAttribute("fileUploadError", "* 文件上传失败");
					e.printStackTrace();
				}
				logoPicPath = request.getContextPath()
						+ "/statics/uploadfiles/" + fileName; // 用于保存图片相对路径格式如：/AppInfoSystem/statics/uploadfiles/com.lbe.security.jpg
				logoLocPath = path + File.separator + fileName; // 保存的是图片的绝对路径
			} else {
				session.setAttribute("fileUploadError",
						"* 上传文件格式不是jpg、png、jpeg、pneg");
				isOk = false;
			}
		}
		if (isOk) {
			// 在进行修改操作时，ModifyBy及ModifyDate赋值
			appInfo.setModifyBy(((DevUser) session
					.getAttribute(Constants.DEV_USER_SESSION)).getId()); // 创建者的用户id
			appInfo.setModifyDate(new Date()); // 修改时间
			appInfo.setLogoLocPath(logoLocPath);
			appInfo.setLogoPicPath(logoPicPath);
			int result = devAppInfoService.upAppInfo(appInfo);
			if (result > 0) {
				return "redirect:/devAppInfo/list"; // 修改成功跳转到app列表信息页面
			} else {
				return "developer/appinfomodify"; // 修改失败又跳转回修改页面
			}
		} else {
			return "developer/appinfomodify";// 修改失败又跳转回修改页面
		}
	}

	/**
	 * 跳转到新增版本信息页面
	 * 
	 * @param id
	 *            appInfo的Id
	 * @param model
	 * @return
	 */
	@RequestMapping(value = "/appversionadd/{id}")
	public String appversionadd(@PathVariable("id") Integer id, Model model) {
		// 通过appinfo的id查询所对应的版本信息。
		List<AppVersion> appVersionList = devAppVersionService
				.getAppVersionById(id);
		AppVersion appVersion = new AppVersion();
		// 将从appinfolist.jsp传递过来的appinfo的id保存到appVersion对象中，传递到appversionadd.jsp，用于后面的新增操作。
		appVersion.setAppId(id);
		model.addAttribute("appVersionList", appVersionList);
		model.addAttribute("appVersion", appVersion);
		return "developer/appversionadd";
	}

	// 保存新增的版本信息
	@RequestMapping("/addversionsave")
	public String addVersionSave(
			AppVersion appVersion,
			HttpSession session,
			HttpServletRequest request,
			@RequestParam(value = "a_downloadLink", required = false) MultipartFile attach) {
		// 判断是否执行新增操作
		boolean isOk = true;

		// 文件下载路径
		String downloadLink = null;
		// 文件存储的绝对路径
		String apkLocPath = null;
		// 文件名
		String apkFileName = null;
		if (!attach.isEmpty()) {
			// 创建用于存储文件的文件夹
			String path = request.getSession().getServletContext()
					.getRealPath("statics" + File.separator + "uploadfiles");
			// 原文件名
			String oldFileName = attach.getOriginalFilename();
			// 原文件后缀
			String suffix = FilenameUtils.getExtension(oldFileName);
			if (attach.getSize() > 5000000) { // 如果上传文件的大小超过500kb
				request.setAttribute("fileUploadError",
						"* 上传文件的大小超过500kb，上传失败！");
				isOk = false;
			} else if (suffix.equalsIgnoreCase("apk")) {// 判断后缀是否正确
				AppInfo appInfo = devAppInfoService.queryAppInfoById(
						appVersion.getAppId(), null);
				// 获得apkName
				String apkName = appInfo.getAPKName();
				// 文件名等于apkName+版本号appInfo.getVersionNo(
				apkFileName = apkName + "-" + appVersion.getVersionNo()
						+ ".apk";// apk文件命名：apk名称+版本号+.apk
				File targetFile = new File(path, apkFileName);
				if (!targetFile.exists()) {// 假如文件不存在
					targetFile.mkdirs();// 就创建
				}
				try {
					// 执行上传
					attach.transferTo(targetFile);
				} catch (Exception e) {
					e.printStackTrace();
					session.setAttribute("fileUploadError", "* apk文件上传失败！");
				}
				// 下载路径
				downloadLink = request.getContextPath()
						+ "/statics/uploadfiles/" + apkFileName;
				// 绝对路径
				apkLocPath = path + File.separator + apkFileName;
			} else {
				session.setAttribute("fileUploadError",
						"* 上传文件的格式不正确，请选择正确的apk格式的文件！");
				isOk = false;
			}
		}
		if (isOk) {
			// 创建者id
			appVersion.setCreatedBy(((DevUser) session
					.getAttribute(Constants.DEV_USER_SESSION)).getId());
			// 创建时间
			appVersion.setCreationDate(new Date());
			// 下载路径
			appVersion.setDownloadLink(downloadLink);
			// 存储绝对路径
			appVersion.setApkLocPath(apkLocPath);
			// 文件名
			appVersion.setApkFileName(apkFileName);
			// 执行新增操作
			if (devAppVersionService.insertAppVersion(appVersion)) {
				try {
					// 单击"保存"按扭之后，除了更新APP版本表，还需要更新APP基础信息表的version_id(该字段记录APP最新版本号)。
					AppInfo info = new AppInfo();
					info.setId(appVersion.getAppId());
					// appVersion.getId()拿到的是刚插入后返回的id的值
					info.setVersionId(appVersion.getId());
					// 修改app基础信息（将新版本id修改到数据库中）
					devAppInfoService.upAppInfo(info);
					// 新增成功
					return "redirect:/devAppInfo/list";
				} catch (Exception e) {
					e.printStackTrace();
					// 新增失败
					return "redirect:/devAppInfo/appversionadd/"
							+ appVersion.getAppId();
				}
			} else {
				// 新增失败
				return "redirect:/devAppInfo/appversionadd/"
						+ appVersion.getAppId();
			}
		} else {
			// 新增失败
			return "redirect:/devAppInfo/appversionadd/"
					+ appVersion.getAppId();
		}
	}

	/**
	 * 跳转到修改版本信息页面
	 * 
	 * @param vid
	 *            appInfo实体类的versionId
	 * @param aid
	 *            appInfo实体类的id
	 * @param model
	 * @return
	 */
	@RequestMapping("/appversionmodify")
	public String appVersionModify(@RequestParam("vid") Integer vid,
			@RequestParam("aid") Integer aid, Model model) {
		// 根据appinfo的id查询历史版本列表
		List<AppVersion> appVersionList = devAppVersionService
				.getAppVersionById(aid);
		// 根据AppVersion的id查询版本详情
		AppVersion appVersion = devAppVersionService.getAppVersionByVid(vid);
		model.addAttribute("appVersion", appVersion);
		model.addAttribute("appVersionList", appVersionList);
		// 转发到app版本修改页面
		return "developer/appversionmodify";
	}

	/**
	 * 根据id删除apk文件
	 * 
	 * @param id
	 * @return
	 */
	@RequestMapping(value = "/ajaxDelApk/{id}", method = RequestMethod.GET)
	@ResponseBody
	public Object ajaxDelApk(@PathVariable("id") Integer id) {
		Map<String, String> map = new HashMap<String, String>();
		if (id == null) {
			// 标记id不存在
			map.put("result", "emptyIsId");
		}
		// 根据AppVersion的id查询版本详情
		AppVersion appVersion = devAppVersionService.getAppVersionByVid(id);
		if (appVersion.getDownloadLink() == null) {// 通过id没有查询到版本详情
			// 标记版本不存在
			map.put("result", "empty");
		} else {
			if (devAppVersionService.upApkFile(id) > 0) {
				// 标记删除成功
				map.put("result", "success");
			} else {
				// 标记删除失败
				map.put("result", "failed");
			}
		}
		return map;
	}

	/**
	 * 保存版本修改
	 * 
	 * @param appVersion
	 *            版本实体对象
	 * @param session
	 * @param request
	 * @param attach
	 *            上传文件对象
	 * @return
	 */
	@RequestMapping("/appversionmodifysave")
	public String appVersionModifySave(
			AppVersion appVersion,
			HttpSession session,
			HttpServletRequest request,
			@RequestParam(value = "attach", required = false) MultipartFile attach) {
		// 判断是否执行新增操作
		boolean isOk = true;

		// 文件下载路径
		String downloadLink = null;
		// 文件存储的绝对路径
		String apkLocPath = null;
		// 文件名
		String apkFileName = null;
		if (!attach.isEmpty()) {
			// 创建用于存储文件的文件夹
			String path = request.getSession().getServletContext()
					.getRealPath("statics" + File.separator + "uploadfiles");
			// 原文件名
			String oldFileName = attach.getOriginalFilename();
			// 原文件后缀
			String suffix = FilenameUtils.getExtension(oldFileName);
			if (attach.getSize() > 5000000) { // 如果上传文件的大小超过500kb
				request.setAttribute("fileUploadError",
						"* 上传文件的大小超过500kb，上传失败！");
				isOk = false;
			} else if (suffix.equalsIgnoreCase("apk")) {// 判断后缀是否正确
				AppInfo appInfo = devAppInfoService.queryAppInfoById(
						appVersion.getAppId(), null);
				// 获得apkName
				String apkName = appInfo.getAPKName();
				// 文件名等于apkName+版本号appInfo.getVersionNo(
				apkFileName = apkName + "-" + appVersion.getVersionNo()
						+ ".apk";// apk文件命名：apk名称+版本号+.apk
				File targetFile = new File(path, apkFileName);
				if (!targetFile.exists()) {// 假如文件不存在
					targetFile.mkdirs();// 就创建
				}
				try {
					// 执行上传
					attach.transferTo(targetFile);
				} catch (Exception e) {
					e.printStackTrace();
					session.setAttribute("fileUploadError", "* apk文件上传失败！");
				}
				// 下载路径
				downloadLink = request.getContextPath()
						+ "/statics/uploadfiles/" + apkFileName;
				// 绝对路径
				apkLocPath = path + File.separator + apkFileName;
			} else {
				session.setAttribute("fileUploadError",
						"* 上传文件的格式不正确，请选择正确的apk格式的文件！");
				isOk = false;
			}
		}

		if (isOk) {
			// 修改者id
			appVersion.setModifyBy(((DevUser) session
					.getAttribute(Constants.DEV_USER_SESSION)).getId());
			// 修改时间
			appVersion.setModifyDate(new Date());
			// 下载路径
			appVersion.setDownloadLink(downloadLink);
			// 存储绝对路径
			appVersion.setApkLocPath(apkLocPath);
			// 文件名
			appVersion.setApkFileName(apkFileName);
			try {
				if (devAppVersionService.modifyAppVersion(appVersion) > 0) {
					// 修改成功 返回appinfo页面
					return "redirect:/devAppInfo/list";
				} else {
					// 修改失败 返回修改页面传参 vid 和aid
					return "redirect:/devAppInfo/appversionmodify?aid="
							+ appVersion.getAppId() + "&vid="
							+ appVersion.getId();
				}
			} catch (Exception e) {
				e.printStackTrace();
				// 修改失败 返回修改页面传参 vid 和aid
				return "redirect:/devAppInfo/appversionmodify?aid="
						+ appVersion.getAppId() + "&vid=" + appVersion.getId();
			}
		} else {
			// 修改失败 返回修改页面传参 vid 和aid
			return "redirect:/devAppInfo/appversionmodify?aid="
					+ appVersion.getAppId() + "&vid=" + appVersion.getId();
		}

	}

	/**
	 * 点击查看按钮，跳转到查看页面
	 * 
	 * @param id
	 * @param model
	 * @return
	 */
	@RequestMapping(value = "/appview/{id}")
	public String appview(@PathVariable("id") Integer id, Model model) {
		// 根据appinfo的id查询历史版本列表
		List<AppVersion> appVersionList = devAppVersionService
				.getAppVersionById(id);
		// 通过id查询appinfo
		AppInfo appInfo = devAppInfoService.queryAppInfoById(id, null);
		model.addAttribute("appVersionList", appVersionList);
		model.addAttribute(appInfo);
		return "developer/appinfoview";
	}

	/**
	 * ajax执行上下架操作
	 * 
	 * @param id
	 * @param session
	 * @return
	 */
	@RequestMapping(value = "/ajaxUpDown/{id}")
	@ResponseBody
	public Object ajaxUpDown(@PathVariable("id") Integer id, HttpSession session) {
		Map<String, Object> map = new HashMap<String, Object>();
		// 标识id参数正确
		map.put("errorCode", "0");
		if (id > 0) {
			try {
				// 通过id查询需要上下架的appinfo
				AppInfo appInfo = devAppInfoService.queryAppInfoById(id, null);
				// 通过appInfo的versionId查询版本信息
				AppVersion appVersion = devAppVersionService
						.getAppVersionByVid(appInfo.getVersionId());
				// 获得登陆者的id(当作修改者的id用)
				int devUserId = ((DevUser) session
						.getAttribute(Constants.DEV_USER_SESSION)).getId();
				// set修改者id
				appInfo.setModifyBy(devUserId);
				// set修改时间
				appInfo.setModifyDate(new Date());
				// 区分上下架操作
				// 判断当前状态为审核通过|下架可上架，当前状态为上架就可以下架
				switch (appInfo.getStatus()) {
				case 2:
					// 状态为审核通过，将状态更改为上架
					appInfo.setStatus(4);
					// set上架时间
					appInfo.setOnSaleDate(new Date());
					break;
				case 5:
					// 状态为下架，将状态更改为上架
					appInfo.setStatus(4);
					// set上架时间
					appInfo.setOnSaleDate(new Date());
					break;
				case 4:
					// 状态为上架，将状态更改为下架
					appInfo.setStatus(5);
					// set下架时间
					appInfo.setOffSaleDate(new Date());
					break;
				}
				// 执行修改appinfo的操作
				if (devAppInfoService.upAppInfo(appInfo) > 0) {
					// 区分发布状态（预发布，不发布就改为已发布，已发布就改为不发布）
					switch (appVersion.getPublishStatus()) {
					case 1:
						// 改为已发布
						appVersion.setPublishStatus(2);
						break;
					case 3:
						// 改为已发布
						appVersion.setPublishStatus(2);
						break;
					case 2:
						// 改为不发布
						appVersion.setPublishStatus(1);
						break;
					}
					if (devAppVersionService.modifyAppVersion(appVersion) > 0) {
						// 标识上下架成功
						map.put("resultMsg", "success");
					} else {
						// 标识上下架失败
						map.put("resultMsg", "failed");
					}
				} else {
					// 标识上下架失败
					map.put("resultMsg", "failed");
				}
			} catch (Exception e) {
				// 标识系统出现错误
				map.put("errorCode", "exception000001");
			}
		} else {
			// 标识id参数出现错误
			map.put("errorCode", "param000001");
		}
		return map;
	}

	@RequestMapping(value = "/ajaxDelAppInfo/{appId}")
	@ResponseBody
	public Object ajaxDelAppInfo(@PathVariable("appId") Integer appId) {
		Map<String, String> map = new HashMap<String, String>();
		if (devAppVersionService.delAppVersionByAppId(appId)) {
			if (devAppInfoService.delAppInfoById(appId)) {
				//标识 删除成功
				map.put("delResult", "true");
			} else {
				//标识 删除失败
				map.put("delResult", "false");
			}
		} else {
			//标识 删除失败
			map.put("delResult", "false");
		}
		return map;
	}
}
